استدلال النوع الشرطي: إتقان الكلمة المفتاحية 'infer' في TypeScript

يقدم نظام الأنواع في TypeScript أدوات قوية لإنشاء كود قوي وقابل للصيانة. ومن بين هذه الأدوات، تبرز الأنواع الشرطية كآلية متعددة الاستخدامات للتعبير عن علاقات الأنواع المعقدة. تفتح الكلمة المفتاحية infer، على وجه التحديد، إمكانيات متقدمة داخل الأنواع الشرطية، مما يسمح باستخراج الأنواع ومعالجتها بطرق متطورة. سيستكشف هذا الدليل الشامل تعقيدات infer، ويوفر أمثلة عملية ورؤى لمساعدتك على إتقان استخدامها.

فهم الأنواع الشرطية

قبل الخوض في infer، من الضروري فهم أساسيات الأنواع الشرطية. تتيح لك الأنواع الشرطية تعريف أنواع تعتمد على شرط، على غرار عامل التشغيل الثلاثي في JavaScript. يتبع بناء الجملة هذا النمط:

            T extends U ? X : Y
            

              
                Copy
              
            
          

هنا، إذا كان النوع T قابلاً للإسناد إلى النوع U، فإن النوع الناتج هو X؛ وإلا، فهو Y.

مثال:

            type IsString<T> = T extends string ? true : false;

type StringCheck = IsString<string>; // type StringCheck = true
type NumberCheck = IsString<number>; // type NumberCheck = false
            

              
                Copy
              
            
          

يوضح هذا المثال البسيط كيف يمكن استخدام الأنواع الشرطية لتحديد ما إذا كان النوع سلسلة نصية أم لا. يمتد هذا المفهوم إلى سيناريوهات أكثر تعقيدًا، مما يمهد الطريق للكلمة المفتاحية infer.

مقدمة عن الكلمة المفتاحية 'infer'

تُستخدم الكلمة المفتاحية infer داخل الفرع true من النوع الشرطي لتقديم متغير نوع يمكن استنتاجه من النوع الذي يتم فحصه. يتيح لك هذا استخراج أجزاء معينة من النوع واستخدامها في النوع الناتج.

بناء الجملة:

            T extends (infer R) ? X : Y
            

              
                Copy
              
            
          

في بناء الجملة هذا، R هو متغير نوع سيتم استنتاجه من بنية T. إذا كان T يطابق النمط، فإن R سيحتفظ بالنوع المستنتج، وسيكون النوع الناتج هو X؛ وإلا، فسيكون Y.

أمثلة أساسية لاستخدام 'infer'

1. استدلال نوع الإرجاع لدالة

من حالات الاستخدام الشائعة استنتاج نوع الإرجاع لدالة. يمكن تحقيق ذلك باستخدام النوع الشرطي التالي:

            type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
            

              
                Copy
              
            
          

الشرح:

• T extends (...args: any) => any: يضمن هذا القيد أن T دالة.
• (...args: any) => infer R: يطابق هذا النمط دالة ويستنتج نوع الإرجاع كـ R.
• R : any: إذا لم يكن T دالة، فإن النوع الناتج هو any.

مثال:

            function greet(name: string): string {
  return `Hello, ${name}!`;
}

type GreetingReturnType = ReturnType<typeof greet>; // type GreetingReturnType = string

function calculate(a: number, b: number): number {
  return a + b;
}

type CalculateReturnType = ReturnType<typeof calculate>; // type CalculateReturnType = number

            

              
                Copy
              
            
          

يوضح هذا المثال كيف تستخرج ReturnType بنجاح أنواع الإرجاع لدالتي greet و calculate.

2. استدلال نوع عنصر المصفوفة

حالة استخدام متكررة أخرى هي استخراج نوع العنصر من المصفوفة:

            type ElementType<T> = T extends (infer U)[] ? U : never;
            

              
                Copy
              
            
          

الشرح:

• T extends (infer U)[]: يطابق هذا النمط مصفوفة ويستنتج نوع العنصر كـ U.
• U : never: إذا لم يكن T مصفوفة، فإن النوع الناتج هو never.

مثال:

            type StringArrayElement = ElementType<string[]>; // type StringArrayElement = string
type NumberArrayElement = ElementType<number[]>; // type NumberArrayElement = number
type MixedArrayElement = ElementType<(string | number)[]>; // type MixedArrayElement = string | number

type NotAnArray = ElementType<number>; // type NotAnArray = never
            

              
                Copy
              
            
          

يوضح هذا كيف تستنتج ElementType نوع العنصر بشكل صحيح لمختلف أنواع المصفوفات.

الاستخدام المتقدم لكلمة 'infer'

1. استدلال معلمات دالة

على غرار استدلال نوع الإرجاع، يمكنك استدلال معلمات دالة باستخدام infer والمصفوفات القيمية (tuples):

            type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
            

              
                Copy
              
            
          

الشرح:

• T extends (...args: any) => any: يضمن هذا القيد أن T دالة.
• (...args: infer P) => any: يطابق هذا النمط دالة ويستنتج أنواع المعلمات كمصفوفة قيمية P.
• P : never: إذا لم يكن T دالة، فإن النوع الناتج هو never.

مثال:

            function logMessage(message: string, level: 'info' | 'warn' | 'error'): void {
  console.log(`[${level.toUpperCase()}] ${message}`);
}

type LogMessageParams = Parameters<typeof logMessage>; // type LogMessageParams = [message: string, level: "info" | "warn" | "error"]

function processData(data: any[], callback: (item: any) => void): void {
  data.forEach(callback);
}

type ProcessDataParams = Parameters<typeof processData>; // type ProcessDataParams = [data: any[], callback: (item: any) => void]
            

              
                Copy
              
            
          

تستخرج Parameters أنواع المعلمات كمصفوفة قيمية (tuple)، مع الحفاظ على ترتيب وأنواع وسيطات الدالة.

2. استخراج الخصائص من نوع كائن

يمكن أيضًا استخدام infer لاستخراج خصائص معينة من نوع كائن. يتطلب ذلك نوعًا شرطيًا أكثر تعقيدًا، ولكنه يتيح معالجة قوية للأنواع.

            type PickByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};
            

              
                Copy
              
            
          

الشرح:

• K in keyof T: يتكرر هذا على جميع مفاتيح النوع T.
• T[K] extends U ? K : never: يتحقق هذا النوع الشرطي مما إذا كان نوع الخاصية عند المفتاح K (أي T[K]) قابلاً للإسناد إلى النوع U. إذا كان كذلك، يتم تضمين المفتاح K في النوع الناتج؛ وإلا، يتم استبعاده باستخدام never.
• تُنشئ هذه البنية بأكملها نوع كائن جديد يحتوي على الخصائص التي تمتد أنواعها إلى U فقط.

مثال:

            interface Person {
  name: string;
  age: number;
  city: string;
  country: string;
}


type StringProperties = PickByType<Person, string>; // type StringProperties = { name: string; city: string; country: string; }

type NumberProperties = PickByType<Person, number>; // type NumberProperties = { age: number; }

            

              
                Copy
              
            
          

تسمح لك PickByType بإنشاء نوع جديد يحتوي فقط على خصائص من نوع معين من نوع موجود.

3. استدلال الأنواع المتداخلة

يمكن ربط infer وتداخلها لاستخراج الأنواع من الهياكل المتداخلة بعمق. على سبيل المثال، فكر في استخراج نوع العنصر الأعمق لمصفوفة متداخلة.

            type DeepArrayElement<T> = T extends (infer U)[] ? DeepArrayElement<U> : T;
            

              
                Copy
              
            
          

الشرح:

• T extends (infer U)[]: يتحقق هذا مما إذا كان T مصفوفة ويستنتج نوع العنصر كـ U.
• DeepArrayElement<U>: إذا كان T مصفوفة، فإن النوع يستدعي DeepArrayElement بشكل متكرر مع نوع العنصر U.
• T: إذا لم يكن T مصفوفة، فإن النوع يعيد T نفسه.

مثال:

            type NestedStringArray = string[][][];
type DeepString = DeepArrayElement<NestedStringArray>; // type DeepString = string

type MixedNestedArray = (number | string)[][][][];
type DeepMixed = DeepArrayElement<MixedNestedArray>; // type DeepMixed = string | number

type RegularNumber = DeepArrayElement<number>; // type RegularNumber = number
            

              
                Copy
              
            
          

يسمح لك هذا النهج التكراري باستخراج نوع العنصر في أعمق مستوى من التداخل في المصفوفة.

تطبيقات العالم الحقيقي

تجد الكلمة المفتاحية infer تطبيقات في سيناريوهات مختلفة تتطلب معالجة ديناميكية للأنواع. فيما يلي بعض الأمثلة العملية:

1. إنشاء باعث أحداث آمن للأنواع

يمكنك استخدام infer لإنشاء باعث أحداث آمن للأنواع يضمن تلقي معالجات الأحداث لنوع البيانات الصحيح.

            type EventMap = {
  'data': { value: string };
  'error': { message: string };
};

type EventName<T extends EventMap> = keyof T;

type EventData<T extends EventMap, K extends EventName<T>> = T[K];

type EventHandler<T extends EventMap, K extends EventName<T>> = (data: EventData<T, K>) => void;

class EventEmitter<T extends EventMap> {
  private listeners: { [K in EventName<T>]?: EventHandler<T, K>[] } = {};

  on<K extends EventName<T>>(event: K, handler: EventHandler<T, K>): void {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event]!.push(handler);
  }

  emit<K extends EventName<T>>(event: K, data: EventData<T, K>): void {
    this.listeners[event]?.forEach(handler => handler(data));
  }
}


const emitter = new EventEmitter<EventMap>();

emitter.on('data', (data) => {
  console.log(`Received data: ${data.value}`);
});

emitter.on('error', (error) => {
  console.error(`An error occurred: ${error.message}`);
});

emitter.emit('data', { value: 'Hello, world!' });

emitter.emit('error', { message: 'Something went wrong.' });

            

              
                Copy
              
            
          

في هذا المثال، تستخدم EventData الأنواع الشرطية و infer لاستخراج نوع البيانات المرتبط باسم حدث معين، مما يضمن تلقي معالجات الأحداث لنوع البيانات الصحيح.

2. تطبيق دالة Reducer آمنة للأنواع

يمكنك الاستفادة من infer لإنشاء دالة Reducer آمنة للأنواع لإدارة الحالة.

            type Action<T extends string, P = undefined> = P extends undefined
  ? { type: T }
  : { type: T; payload: P };

type Reducer<S, A extends Action<string>> = (state: S, action: A) => S;

// Example Actions
type IncrementAction = Action<'INCREMENT'>;
type DecrementAction = Action<'DECREMENT'>;
type SetValueAction = Action<'SET_VALUE', number>;


// Example State
interface CounterState {
  value: number;
}

// Example Reducer
const counterReducer: Reducer<CounterState, IncrementAction | DecrementAction | SetValueAction> = (
  state: CounterState,
  action: IncrementAction | DecrementAction | SetValueAction
): CounterState => {
  switch (action.type) {
    case 'INCREMENT':
      return { ...state, value: state.value + 1 };
    case 'DECREMENT':
      return { ...state, value: state.value - 1 };
    case 'SET_VALUE':
      return { ...state, value: action.payload };
    default:
      return state;
  }
};

// Usage
const initialState: CounterState = { value: 0 };
const newState1 = counterReducer(initialState, { type: 'INCREMENT' }); // newState1.value is 1
const newState2 = counterReducer(newState1, { type: 'SET_VALUE', payload: 10 }); // newState2.value is 10

            

              
                Copy
              
            
          

في حين أن هذا المثال لا يستخدم infer بشكل مباشر، فإنه يضع الأساس لسيناريوهات Reducer أكثر تعقيدًا. يمكن تطبيق infer لاستخراج نوع payload ديناميكيًا من أنواع Action المختلفة، مما يسمح بفحص أكثر صرامة للأنواع داخل دالة Reducer. وهذا مفيد بشكل خاص في التطبيقات الكبيرة التي تحتوي على العديد من الإجراءات وهياكل الحالة المعقدة.

3. توليد الأنواع ديناميكيًا من استجابات API

عند العمل مع واجهات برمجة التطبيقات (APIs)، يمكنك استخدام infer لتوليد أنواع TypeScript تلقائيًا من بنية استجابات API. يساعد هذا على ضمان أمان الأنواع عند التفاعل مع مصادر البيانات الخارجية.

لنفترض سيناريو مبسطًا حيث تريد استخراج نوع البيانات من استجابة API عامة:

            type ApiResponse<T> = {
  status: number;
  data: T;
  message?: string;
};

type ExtractDataType<T> = T extends ApiResponse<infer U> ? U : never;

// Example API Response
type User = {
  id: number;
  name: string;
  email: string;
};

type UserApiResponse = ApiResponse<User>;

type ExtractedUser = ExtractDataType<UserApiResponse>; // type ExtractedUser = User

            

              
                Copy
              
            
          

تستخدم ExtractDataType الكلمة المفتاحية infer لاستخراج النوع U من ApiResponse<U>، مما يوفر طريقة آمنة للأنواع للوصول إلى بنية البيانات التي تعيدها API.

أفضل الممارسات والاعتبارات

• الوضوح وسهولة القراءة: استخدم أسماء متغيرات أنواع وصفية (على سبيل المثال، ReturnType بدلاً من R فقط) لتحسين قابلية قراءة الكود.
• الأداء: بينما infer قوية، فإن الاستخدام المفرط يمكن أن يؤثر على أداء فحص الأنواع. استخدمها بحكمة، خاصة في قواعد الأكواد الكبيرة.
• معالجة الأخطاء: قدم دائمًا نوعًا احتياطيًا (على سبيل المثال، any أو never) في الفرع false من النوع الشرطي للتعامل مع الحالات التي لا يتطابق فيها النوع مع النمط المتوقع.
• التعقيد: تجنب الأنواع الشرطية المعقدة بشكل مفرط مع عبارات infer المتداخلة، حيث يمكن أن تصبح صعبة الفهم والصيانة. أعد هيكلة الكود الخاص بك إلى أنواع أصغر وأسهل في الإدارة عند الضرورة.
• الاختبار: اختبر أنواعك الشرطية بدقة باستخدام أنواع إدخال مختلفة للتأكد من أنها تتصرف كما هو متوقع.

اعتبارات عالمية

عند استخدام TypeScript و infer في سياق عالمي، ضع في اعتبارك ما يلي:

• التعريب والتدويل (i18n): قد تحتاج الأنواع إلى التكيف مع اللغات وتنسيقات البيانات المختلفة. استخدم الأنواع الشرطية و infer للتعامل ديناميكيًا مع هياكل البيانات المتغيرة بناءً على المتطلبات الخاصة باللغة المحلية. على سبيل المثال، يمكن تمثيل التواريخ والعملات بشكل مختلف عبر البلدان.
• تصميم واجهة برمجة التطبيقات (API) للجماهير العالمية: صمم واجهات برمجة التطبيقات الخاصة بك مع مراعاة إمكانية الوصول العالمية. استخدم هياكل وتنسيقات بيانات متسقة يسهل فهمها ومعالجتها بغض النظر عن موقع المستخدم. يجب أن تعكس تعريفات الأنواع هذا الاتساق.
• المناطق الزمنية: عند التعامل مع التواريخ والأوقات، انتبه لاختلافات المناطق الزمنية. استخدم المكتبات المناسبة (مثل Luxon، date-fns) للتعامل مع تحويلات المناطق الزمنية وضمان تمثيل دقيق للبيانات عبر المناطق المختلفة. فكر في تمثيل التواريخ والأوقات بتنسيق التوقيت العالمي المنسق (UTC) في استجابات واجهة برمجة التطبيقات الخاصة بك.
• الاختلافات الثقافية: كن على دراية بالاختلافات الثقافية في تمثيل البيانات وتفسيرها. على سبيل المثال، يمكن أن يكون للأسماء والعناوين وأرقام الهواتف تنسيقات مختلفة في بلدان مختلفة. تأكد من أن تعريفات الأنواع الخاصة بك يمكن أن تستوعب هذه الاختلافات.
• التعامل مع العملات: عند التعامل مع القيم النقدية، استخدم تمثيلاً متسقًا للعملة (مثل رموز العملة ISO 4217) وتعامل مع تحويلات العملة بشكل مناسب. استخدم المكتبات المصممة لمعالجة العملات لتجنب مشكلات الدقة وضمان حسابات دقيقة.

على سبيل المثال، فكر في سيناريو تقوم فيه بجلب ملفات تعريف المستخدمين من مناطق مختلفة، ويختلف تنسيق العنوان بناءً على البلد. يمكنك استخدام الأنواع الشرطية و infer لضبط تعريف النوع ديناميكيًا بناءً على موقع المستخدم:

            type AddressFormat<CountryCode extends string> = CountryCode extends 'US'
    ? { street: string; city: string; state: string; zipCode: string; }
    : CountryCode extends 'CA'
    ? { street: string; city: string; province: string; postalCode: string; }
    : { addressLines: string[]; city: string; country: string; };

type UserProfile<CountryCode extends string> = {
    id: number;
    name: string;
    email: string;
    address: AddressFormat<CountryCode>;
    countryCode: CountryCode; // Add country code to profile
};

// Example Usage
type USUserProfile = UserProfile<'US'>; // Has US address format
type CAUserProfile = UserProfile<'CA'>; // Has Canadian address format
type GenericUserProfile = UserProfile<'DE'>; // Has Generic (international) address format

            

              
                Copy
              
            
          

من خلال تضمين countryCode في نوع UserProfile واستخدام الأنواع الشرطية بناءً على هذا الرمز، يمكنك ضبط نوع address ديناميكيًا ليتناسب مع التنسيق المتوقع لكل منطقة. يتيح ذلك معالجة آمنة للأنواع لتنسيقات البيانات المتنوعة عبر مختلف البلدان.

الخاتمة

تُعد الكلمة المفتاحية infer إضافة قوية لنظام الأنواع في TypeScript، حيث تتيح معالجة واستخراج الأنواع المتطورة ضمن الأنواع الشرطية. بإتقان infer، يمكنك إنشاء كود أكثر قوة وأمانًا للأنواع وقابلية للصيانة. من استدلال أنواع الإرجاع للدوال إلى استخراج الخصائص من الكائنات المعقدة، فإن الاحتمالات واسعة. تذكر استخدام infer بحكمة، مع إعطاء الأولوية للوضوح وسهولة القراءة لضمان بقاء الكود الخاص بك مفهومًا وقابلًا للصيانة على المدى الطويل.

لقد قدم هذا الدليل نظرة عامة شاملة على infer وتطبيقاتها. جرب الأمثلة المقدمة، واستكشف حالات استخدام إضافية، واستفد من infer لتعزيز سير عمل تطوير TypeScript الخاص بك.